home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / dalla rivista / host contacted / jikes.lha / jikes-1.11 / src / table.h < prev    next >
C/C++ Source or Header  |  1999-08-26  |  13KB  |  439 lines
  1. // $Id: table.h,v 1.7 1999/08/26 15:34:10 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #ifndef table_INCLUDED
  11. #define table_INCLUDED
  12.  
  13. #include "config.h"
  14. #include "symbol.h"
  15.  
  16. class VariableShadowSymbol
  17. {
  18. public:
  19.     VariableSymbol *variable_symbol;
  20.  
  21.     VariableShadowSymbol(VariableSymbol *variable_symbol_) : variable_symbol(variable_symbol_),
  22.                                                              conflict(NULL)
  23.     {}
  24.  
  25.     ~VariableShadowSymbol()
  26.     {
  27.         delete conflict;
  28.     }
  29.  
  30.     VariableSymbol *Conflict(int i) { return (*conflict)[i]; }
  31.  
  32.     inline int NumConflicts()
  33.     {
  34.         return (conflict ? conflict -> Length() : 0);
  35.     }
  36.     inline void AddConflict(VariableSymbol *conflict_symbol)
  37.     {
  38.         if ((variable_symbol != conflict_symbol) && (! Find(conflict_symbol)))
  39.             conflict -> Next() = conflict_symbol;
  40.         return;
  41.     }
  42.     inline void CompressSpace()
  43.     {
  44.         if (conflict)
  45.             (void) conflict -> Array();
  46.     }
  47.  
  48. private:
  49.     friend class ExpandedFieldTable;
  50.     VariableShadowSymbol *next;
  51.  
  52.     ConvertibleArray<VariableSymbol *> *conflict;
  53.  
  54.     bool Find(VariableSymbol *conflict_symbol)
  55.     {
  56.         if (! conflict)
  57.             conflict = new ConvertibleArray<VariableSymbol *>(4);
  58.         for (int k = 0; k < conflict -> Length(); k++)
  59.             if ((*conflict)[k] == conflict_symbol)
  60.                 return true;
  61.         return false;
  62.     }
  63. };
  64.  
  65.  
  66. class MethodShadowSymbol
  67. {
  68. public:
  69.     MethodSymbol *method_symbol;
  70.     MethodShadowSymbol *next_method;
  71.  
  72.     MethodShadowSymbol(MethodSymbol *method_symbol_) : method_symbol(method_symbol_),
  73.                                                        conflict(NULL)
  74.     {}
  75.  
  76.     ~MethodShadowSymbol()
  77.     {
  78.         delete conflict;
  79.     }
  80.  
  81.     MethodSymbol *Conflict(const int i) { return (*conflict)[i]; }
  82.  
  83.     inline int NumConflicts()
  84.     {
  85.         return (conflict ? conflict -> Length() : 0);
  86.     }
  87.     inline void AddConflict(MethodSymbol *conflict_symbol)
  88.     {
  89.         if ((method_symbol != conflict_symbol) && (! Find(conflict_symbol)))
  90.             conflict -> Next() = conflict_symbol;
  91.         return;
  92.     }
  93.     inline void RemoveConflicts()
  94.     {
  95.         delete conflict;
  96.         conflict = NULL;
  97.     }
  98.  
  99.     inline void CompressSpace()
  100.     {
  101.         if (conflict)
  102.             (void) conflict -> Array();
  103.     }
  104.  
  105. private:
  106.     friend class ExpandedMethodTable;
  107.     MethodShadowSymbol *next;
  108.  
  109.     ConvertibleArray<MethodSymbol *> *conflict;
  110.  
  111.     bool Find(MethodSymbol *conflict_symbol)
  112.     {
  113.         if (! conflict)
  114.             conflict = new ConvertibleArray<MethodSymbol *>(4);
  115.         for (int k = 0; k < conflict -> Length(); k++)
  116.             if ((*conflict)[k] == conflict_symbol)
  117.                 return true;
  118.         return false;
  119.     }
  120. };
  121.  
  122.  
  123. class TypeShadowSymbol
  124. {
  125. public:
  126.     TypeSymbol *type_symbol;
  127.  
  128.     TypeShadowSymbol(TypeSymbol *type_symbol_) : type_symbol(type_symbol_),
  129.                                                  conflict(NULL)
  130.     {}
  131.  
  132.     ~TypeShadowSymbol()
  133.     {
  134.         delete conflict;
  135.     }
  136.  
  137.     TypeSymbol *Conflict(int i) { return (*conflict)[i]; }
  138.  
  139.     inline int NumConflicts()
  140.     {
  141.         return (conflict ? conflict -> Length() : 0);
  142.     }
  143.  
  144.     inline void AddConflict(TypeSymbol *conflict_symbol)
  145.     {
  146.         if ((type_symbol != conflict_symbol) && (! Find(conflict_symbol)))
  147.             conflict -> Next() = conflict_symbol;
  148.         return;
  149.     }
  150.  
  151.     inline void CompressSpace()
  152.     {
  153.         if (conflict)
  154.             (void) conflict -> Array();
  155.     }
  156.  
  157. private:
  158.     friend class ExpandedTypeTable;
  159.     TypeShadowSymbol *next;
  160.  
  161.     ConvertibleArray<TypeSymbol *> *conflict;
  162.  
  163.     bool Find(TypeSymbol *conflict_symbol)
  164.     {
  165.         if (! conflict)
  166.             conflict = new ConvertibleArray<TypeSymbol *>(4);
  167.         for (int k = 0; k < conflict -> Length(); k++)
  168.             if ((*conflict)[k] == conflict_symbol)
  169.                 return true;
  170.         return false;
  171.     }
  172. };
  173.  
  174.  
  175. class ExpandedTypeTable
  176. {
  177. public:
  178.     enum
  179.     {
  180.         DEFAULT_HASH_SIZE = 251,
  181.         MAX_HASH_SIZE = 509
  182.     };
  183.  
  184.     ConvertibleArray<TypeShadowSymbol *> symbol_pool;
  185.  
  186.     inline void CompressSpace()
  187.     {
  188.         hash_size = symbol_pool.Length();
  189.         hash_size = (hash_size <= 0 ? 1 : (hash_size > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size));
  190.         delete [] base;
  191.         base = (TypeShadowSymbol **) memset(new TypeShadowSymbol *[hash_size], 0, hash_size * sizeof(TypeShadowSymbol *));
  192.  
  193.         TypeShadowSymbol **array = symbol_pool.Array();
  194.         for (int i = 0; i < symbol_pool.Length(); i++)
  195.         {
  196.             array[i] -> CompressSpace();
  197.  
  198.             int k = array[i] -> type_symbol -> name_symbol -> index % hash_size;
  199.             array[i] -> next = base[k];
  200.             base[k] = array[i];
  201.         }
  202.     }
  203.  
  204.     ExpandedTypeTable(int hash_size_ = DEFAULT_HASH_SIZE) : symbol_pool(10, 4)
  205.     {
  206.         hash_size = (hash_size_ <= 0 ? 1 : (hash_size_ > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size_));
  207.         base = (TypeShadowSymbol **) memset(new TypeShadowSymbol *[hash_size], 0, hash_size * sizeof(TypeShadowSymbol *));
  208.     }
  209.  
  210.     ~ExpandedTypeTable()
  211.     {
  212.         for (int k = 0; k < symbol_pool.Length(); k++)
  213.             delete symbol_pool[k];
  214.         delete [] base;
  215.     }
  216.  
  217.     inline TypeShadowSymbol *InsertTypeShadowSymbol(TypeSymbol *type_symbol)
  218.     {
  219.         int i = type_symbol -> name_symbol -> index % hash_size;
  220.         TypeShadowSymbol *p = new TypeShadowSymbol(type_symbol);
  221.         p -> next = base[i];
  222.         base[i] = p;
  223.         symbol_pool.Next() = p;
  224.  
  225.         return p;
  226.     }
  227.  
  228.     inline TypeShadowSymbol *FindTypeShadowSymbol(NameSymbol *name_symbol)
  229.     {
  230.         TypeShadowSymbol *p;
  231.         for (p = base[name_symbol -> index % hash_size]; p; p = p -> next)
  232.              if (p -> type_symbol -> name_symbol == name_symbol)
  233.                  break;
  234.         return p;
  235.     }
  236.  
  237. private:
  238.     TypeShadowSymbol **base;
  239.     int hash_size;
  240. };
  241.  
  242. class ExpandedFieldTable
  243. {
  244. public:
  245.     enum
  246.     {
  247.         DEFAULT_HASH_SIZE = 251,
  248.         MAX_HASH_SIZE = 509
  249.     };
  250.  
  251.     ConvertibleArray<VariableShadowSymbol *> symbol_pool;
  252.  
  253.     inline void CompressSpace()
  254.     {
  255.         hash_size = symbol_pool.Length();
  256.         hash_size = (hash_size <= 0 ? 1 : (hash_size > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size));
  257.         delete [] base;
  258.         base = (VariableShadowSymbol **) memset(new VariableShadowSymbol *[hash_size], 0, hash_size * sizeof(VariableShadowSymbol *));
  259.  
  260.         VariableShadowSymbol **array = symbol_pool.Array();
  261.         for (int i = 0; i < symbol_pool.Length(); i++)
  262.         {
  263.             array[i] -> CompressSpace();
  264.  
  265.             int k = array[i] -> variable_symbol -> name_symbol -> index % hash_size;
  266.             array[i] -> next = base[k];
  267.             base[k] = array[i];
  268.         }
  269.     }
  270.  
  271.     ExpandedFieldTable(int hash_size_ = DEFAULT_HASH_SIZE) : symbol_pool(10, 4)
  272.     {
  273.         hash_size = (hash_size_ <= 0 ? 1 : (hash_size_ > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size_));
  274.         base = (VariableShadowSymbol **) memset(new VariableShadowSymbol *[hash_size], 0, hash_size * sizeof(VariableShadowSymbol *));
  275.     }
  276.     ~ExpandedFieldTable()
  277.     {
  278.         for (int i = 0; i < symbol_pool.Length(); i++)
  279.             delete symbol_pool[i];
  280.         delete [] base;
  281.     }
  282.  
  283.     inline VariableShadowSymbol *InsertVariableShadowSymbol(VariableSymbol *variable_symbol)
  284.     {
  285.         int i = variable_symbol -> name_symbol -> index % hash_size;
  286.         VariableShadowSymbol *p = new VariableShadowSymbol(variable_symbol);
  287.         p -> next = base[i];
  288.         base[i] = p;
  289.         symbol_pool.Next() = p;
  290.  
  291.         return p;
  292.     }
  293.  
  294.     inline VariableShadowSymbol *FindVariableShadowSymbol(NameSymbol *name_symbol)
  295.     {
  296.         VariableShadowSymbol *p;
  297.         for (p = base[name_symbol -> index % hash_size]; p; p = p -> next)
  298.             if (p -> variable_symbol -> name_symbol == name_symbol)
  299.                 break;
  300.         return p;
  301.     }
  302.  
  303. private:
  304.     VariableShadowSymbol **base;
  305.     int hash_size;
  306. };
  307.  
  308.  
  309. class ExpandedMethodTable
  310. {
  311. public:
  312.     enum
  313.     {
  314.         DEFAULT_HASH_SIZE = 251,
  315.         MAX_HASH_SIZE = 509
  316.     };
  317.  
  318.     ConvertibleArray<MethodShadowSymbol *> symbol_pool;
  319.  
  320.     inline void CompressSpace()
  321.     {
  322.         hash_size = symbol_pool.Length();
  323.         hash_size = (hash_size <= 0 ? 1 : (hash_size > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size));
  324.         delete [] base;
  325.         base = (MethodShadowSymbol **) memset(new MethodShadowSymbol *[hash_size], 0, hash_size * sizeof(MethodShadowSymbol *));
  326.  
  327.         MethodShadowSymbol **array = symbol_pool.Array();
  328.         for (int i = 0; i < symbol_pool.Length(); i++)
  329.         {
  330.             array[i] -> CompressSpace();
  331.  
  332.             NameSymbol *name_symbol = array[i] -> method_symbol -> name_symbol;
  333.             MethodShadowSymbol *base_shadow = FindMethodShadowSymbol(name_symbol);
  334.             if (! base_shadow)
  335.             {
  336.                 int k = name_symbol -> index % hash_size;
  337.                 array[i] -> next = base[k];
  338.                 base[k] = array[i];
  339.                 array[i] -> next_method = NULL;
  340.             }
  341.             else
  342.             {
  343.                 array[i] -> next_method = base_shadow -> next_method;
  344.                 base_shadow -> next_method = array[i];
  345.             }
  346.         }
  347.     }
  348.  
  349.     ExpandedMethodTable(int hash_size_ = DEFAULT_HASH_SIZE) : symbol_pool(10, 4)
  350.     {
  351.         hash_size = (hash_size_ <= 0 ? 1 : (hash_size_ > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size_));
  352.         base = (MethodShadowSymbol **) memset(new MethodShadowSymbol *[hash_size], 0, hash_size * sizeof(MethodShadowSymbol *));
  353.     }
  354.     ~ExpandedMethodTable()
  355.     {
  356.         for (int i = 0; i < symbol_pool.Length(); i++)
  357.             delete symbol_pool[i];
  358.        delete [] base;
  359.     }
  360.  
  361.     inline MethodShadowSymbol *FindMethodShadowSymbol(NameSymbol *name_symbol)
  362.     {
  363.         MethodShadowSymbol *p;
  364.         for (p = base[name_symbol -> index % hash_size]; p; p = p -> next)
  365.             if (p -> method_symbol -> name_symbol == name_symbol)
  366.                 break;
  367.         return p;
  368.     }
  369.  
  370.     inline void InsertMethodShadowSymbol(MethodSymbol *method_symbol)
  371.     {
  372.         int i = method_symbol -> name_symbol -> index % hash_size;
  373.         MethodShadowSymbol *p = new MethodShadowSymbol(method_symbol);
  374.         p -> next_method = NULL;
  375.         p -> next = base[i];
  376.         base[i] = p;
  377.         symbol_pool.Next() = p;
  378.  
  379.         return;
  380.     }
  381.  
  382.     inline void Overload(MethodShadowSymbol *base_shadow, MethodSymbol *overload_method)
  383.     {
  384.         MethodShadowSymbol *shadow = new MethodShadowSymbol(overload_method);
  385.         symbol_pool.Next() = shadow;
  386.         shadow -> next_method = base_shadow -> next_method;
  387.         base_shadow -> next_method = shadow;
  388.     }
  389.  
  390.     inline void Overload(MethodSymbol *overload_method)
  391.     {
  392.         MethodShadowSymbol *base_shadow = FindMethodShadowSymbol(overload_method -> name_symbol);
  393.         if (! base_shadow)
  394.              InsertMethodShadowSymbol(overload_method);
  395.         else Overload(base_shadow, overload_method);
  396.     }
  397.  
  398.     MethodShadowSymbol *FindOverloadMethodShadow(MethodSymbol *overload_method, Semantic *sem, LexStream::TokenIndex tok)
  399.     {
  400.         if (! overload_method -> IsTyped())
  401.             overload_method -> ProcessMethodSignature(sem, tok);
  402.  
  403.         for (MethodShadowSymbol *method_shadow = FindMethodShadowSymbol(overload_method -> name_symbol);
  404.              method_shadow;
  405.              method_shadow = method_shadow -> next_method)
  406.         {
  407.             MethodSymbol *method = method_shadow -> method_symbol;
  408.  
  409.             if (overload_method == method)
  410.                 return method_shadow;
  411.  
  412.             if (! method -> IsTyped())
  413.                 method -> ProcessMethodSignature(sem, tok);
  414.  
  415.             if (overload_method -> NumFormalParameters() == method -> NumFormalParameters())
  416.             {
  417.                 int i;
  418.                 for (i = method -> NumFormalParameters() - 1; i >= 0; i--)
  419.                 {
  420.                     if (method -> FormalParameter(i) -> Type() != overload_method -> FormalParameter(i) -> Type())
  421.                         break;
  422.                 }
  423.  
  424.                 if (i < 0)
  425.                     return method_shadow;
  426.             }
  427.         }
  428.  
  429.         return (MethodShadowSymbol *) NULL;
  430.     }
  431.  
  432. private:
  433.     MethodShadowSymbol **base;
  434.     int hash_size;
  435. };
  436. #endif
  437.  
  438.  
  439.